home *** CD-ROM | disk | FTP | other *** search
/ Windows Undocumented File Formats / Windows Undocumented File Formats.img / CHAP4 / TOPICDMP / TOPICDMP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-21  |  14.1 KB  |  381 lines
  1. /**********************************************************************
  2.  *
  3.  * PROGRAM: TOPICDMP.C
  4.  *
  5.  * PURPOSE: Dump the topic file from a Windows .HLP or .MVB file
  6.  *
  7.  * Copyright 1997, Mike Wallace and Pete Davis
  8.  *
  9.  * Chapter 4, Windows Help File Format, from Undocumented Windows
  10.  * File Formats, published by R&D Books, an imprint of Miller Freeman, Inc.
  11.  *
  12.  **********************************************************************/
  13.  
  14. #include <time.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18. #include <conio.h>
  19. #include <ctype.h>
  20. #include <limits.h>
  21.  
  22. #pragma pack(1)   /* Make sure we get byte alignment */
  23. #include "whstruct.h"
  24.  
  25. HELPHEADER        HelpHeader;        /* Header for Help file.       */
  26. WHIFSBTREEHEADER  WHIFSHeader;       /* WHIFS Header record         */
  27. int               WHIFSLeafOne = -1; /* First WHIFS Leaf Node       */
  28. long              FirstPageLoc;      /* Used by macros for b-trees  */
  29. char              *PhrasesPtr; 
  30. int               Compressed;        /* Is there compression?       */
  31.  
  32. #define MSG(s)              { puts(s); return; }
  33. #define FAIL(s)             { puts(s); exit(1); }
  34.  
  35. #define GET_STRING(f, s) \
  36.     { char *p = (char *)(s); while (*p++ = fgetc(f)) ; *p = 0; }
  37.  
  38. #define BIT_SET(map, bit)   (((map) & (1 << (bit))) ? 1 : 0)
  39.  
  40. // Finds the first leaf in the WHIFS B-Tree
  41. void WHIFSGetFirstLeaf(FILE *HelpFile) {
  42.     int               CurrLevel = 1; /* Current Level in B-Tree */
  43.     BTREEINDEXHEADER  CurrNode;      /* Current Node in B-Tree  */
  44.     int               NextPage = 0;  /* Next Page to go to      */
  45.  
  46.     /* Go to the beginning of WHIFS B-Tree */
  47.     fseek(HelpFile, HelpHeader.WHIFS, SEEK_SET);
  48.     fread(&WHIFSHeader, sizeof(WHIFSHeader), 1, HelpFile);
  49.     FirstPageLoc = HelpHeader.WHIFS + sizeof(WHIFSHeader);
  50.     GotoWHIFSPage(WHIFSHeader.RootPage);  // macro in WHSTRUCT.H
  51.  
  52.     /* Find First Leaf */
  53.     while (CurrLevel < WHIFSHeader.NLevels) {
  54.        fread(&CurrNode, sizeof(CurrNode), 1, HelpFile);
  55.  
  56.        /* Next Page is conveniently the first byte of the page */
  57.        fread(&NextPage, sizeof(int), 1, HelpFile);
  58.        GotoWHIFSPage(NextPage);
  59.        CurrLevel++;
  60.     }
  61.     /* First Leaf page is here */
  62.     WHIFSLeafOne = NextPage;
  63. }
  64.  
  65. // Get a WHIFS file by file number; returns offset and filename
  66. void GetFile(FILE *HelpFile, DWORD Number, long *Offset, char *Name) {
  67.     BTREENODEHEADER CurrentNode;      
  68.     DWORD           CurrPage, counter = 0;
  69.     char            c, TempFile[19];
  70.     
  71.     /* Skip pages we don't need */
  72.     CurrentNode.NextPage = WHIFSLeafOne;
  73.     do {
  74.         CurrPage = CurrentNode.NextPage;
  75.         GotoWHIFSPage(CurrPage);
  76.         fread(&CurrentNode, sizeof(CurrentNode), 1, HelpFile);
  77.         counter += CurrentNode.NEntries;
  78.     } while (counter < Number);
  79.  
  80.     for (counter -= CurrentNode.NEntries; counter <= Number; counter++) {
  81.         GET_STRING(HelpFile, TempFile);
  82.         fread(Offset, sizeof(long), 1, HelpFile);
  83.     }
  84.     strcpy(Name, TempFile);
  85. }
  86.  
  87. // Get SysHeader to see if compression used on help file
  88. void SysLoad(FILE *HelpFile, long FileStart) {
  89.    SYSTEMHEADER    SysHeader;
  90.    FILEHEADER      FileHdr;
  91.    fseek(HelpFile, FileStart, SEEK_SET);
  92.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  93.    fread(&SysHeader, sizeof(SysHeader), 1, HelpFile);
  94.    if (SysHeader.Revision != 21)
  95.        FAIL("Sorry, TOPICDMP only works with Windows 3.1 help files");
  96.    Compressed = (SysHeader.Flags & COMPRESSION_310) ||
  97.                 (SysHeader.Flags & COMPRESSION_UNKN);
  98. }
  99.  
  100. // Decides how many bytes to read, depending on number of bits set
  101. int BytesToRead(BYTE BitMap) {
  102.     int TempSum, counter;
  103.     TempSum = 8;
  104.     for (counter = 0; counter < 8; counter ++)
  105.        TempSum += BIT_SET(BitMap, counter);
  106.     return TempSum;
  107. }
  108.  
  109. // Decompresses the data using Microsoft's LZ77 derivative.
  110. long Decompress(FILE *HelpFile, long CompSize, char *Buffer) {
  111.    long InBytes = 0;        /* How many bytes read in                    */
  112.    WORD OutBytes = 0;       /* How many bytes written out                */
  113.    BYTE BitMap, Set[16];    /* Bitmap and bytes associated with it       */
  114.    long NumToRead;          /* Number of bytes to read for next group    */
  115.    int  counter, Index;     /* Going through next 8-16 codes or chars    */
  116.    int  Length, Distance;   /* Code length and distance back in 'window' */
  117.    char *CurrPos;           /* Where we are at any given moment          */
  118.    char *CodePtr;           /* Pointer to back-up in LZ77 'window'       */
  119.  
  120.    CurrPos = Buffer;
  121.    while (InBytes < CompSize) {
  122.       BitMap = (BYTE) fgetc(HelpFile);
  123.       NumToRead = BytesToRead(BitMap);
  124.  
  125.       if ((CompSize - InBytes) < NumToRead) 
  126.           NumToRead = CompSize - InBytes;   // only read what we have left
  127.       fread(Set, 1, (int) NumToRead, HelpFile);    
  128.       InBytes += NumToRead + 1;
  129.  
  130.       /* Go through and decode data */
  131.       for (counter = 0, Index = 0; counter < 8; counter++) {
  132.          /* It's a code, so decode it and copy the data */
  133.          if (BIT_SET(BitMap, counter)) {
  134.             Length = ((Set[Index+1] & 0xF0) >> 4) + 3;
  135.             Distance = (256 * (Set[Index+1] & 0x0F)) + Set[Index] + 1;
  136.             CodePtr = CurrPos - Distance;   // ptr into decompress window
  137.             while (Length)
  138.                { *CurrPos++ = *CodePtr++; OutBytes++; Length--; } 
  139.             Index += 2;  /* codes are 2 bytes */
  140.          }
  141.          else 
  142.             { *CurrPos++ = Set[Index++]; OutBytes++; }
  143.       }
  144.    }
  145.    return OutBytes;
  146. } 
  147.    
  148. // Prints a Phrase from the Phrase table
  149. void PrintPhrase(char *Phrases, int PhraseNum) {
  150.     int *Offsets = (int *)Phrases;
  151.     char *p = Phrases+Offsets[PhraseNum];
  152.     while (p < Phrases + Offsets[PhraseNum + 1])
  153.         { putchar(*p); p++; }
  154. }
  155.  
  156. // Build up a table of phrases
  157. void PhrasesLoad(FILE *HelpFile, long FileStart) {
  158.    FILEHEADER      FileHdr;
  159.    PHRASEHDR       PhraseHdr;
  160.    int             *Offsets;
  161.    char            *Phrases;
  162.    long            DeCompSize;
  163.  
  164.    /* Go to the phrases file and get the headers */
  165.    fseek(HelpFile, FileStart, SEEK_SET);
  166.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  167.    fread(&PhraseHdr, sizeof(PhraseHdr), 1, HelpFile);
  168.  
  169.    /* Allocate space and decompress if it's compressed, else read in. */
  170.    if (Compressed) {
  171.       if ((Offsets = malloc((unsigned) (PhraseHdr.PhrasesSize + 
  172.           (PhraseHdr.NumPhrases + 1) * 2))) == NULL)
  173.         MSG("No room to decompress |Phrases");
  174.       Phrases = Offsets + fread(Offsets,2,PhraseHdr.NumPhrases+1, HelpFile);
  175.       DeCompSize = Decompress(HelpFile, (long)FileHdr.FileSize - 
  176.           (sizeof(PhraseHdr) + 2 * (PhraseHdr.NumPhrases+1)), Phrases);
  177.       if (DeCompSize != PhraseHdr.PhrasesSize) {
  178.          printf("\n");
  179.       }
  180.    }
  181.    else {
  182.       if (!(Offsets=malloc((unsigned)(FileHdr.FileSize-sizeof(PhraseHdr)))))
  183.          MSG("No room to decompress |Phrases");
  184.       /* Backup 4 bytes for uncompressed Phrases (no PhrasesSize) */
  185.       fseek(HelpFile, -4, SEEK_CUR);
  186.       fread(Offsets, (unsigned) (FileHdr.FileSize - 4), 1, HelpFile);
  187.    }
  188.    PhrasesPtr = Phrases = (char *) Offsets;
  189. }
  190.  
  191. /* Because the topic file is broken into 4k blocks, we'll have to handle
  192. all the reads.  The idea is to filter out the TOPICBLOCKHEADERs and
  193. do any decompression that needs doing. */
  194. long TopicRead(BYTE *Dest, long NumBytes, FILE *HelpFile) {
  195.    static long        CurrBlockLoc = 0;   /* Where we are in the block  */
  196.    static BYTE        *DCmpBlock = NULL;  /* Block of uncompressed data */
  197.    static long        DecompSize;         /* Size of block after decomp */
  198.    static long        TopicStart, BlkNum; /* Start of |TOPIC file       */
  199.    long               BytesLeft;          /* # Bytes left to return     */
  200.    TOPICBLOCKHEADER   BlockHeader;
  201.    TOPICLINK          *TempLink;
  202.    long               EndOffset;
  203.  
  204.    /* If NumBytes = 0, then we're done and need to free memory */
  205.    if (NumBytes == -1) { free(DCmpBlock); return 0; }
  206.  
  207.    if (!DCmpBlock) {
  208.       if (Compressed) {
  209.          if (! (DCmpBlock = malloc((unsigned) (4 * TopicBlockSize))))
  210.              FAIL("Not enough memory to decompress |TOPIC file");
  211.          TopicStart = ftell(HelpFile);
  212.          BlkNum = 0;
  213.       }
  214.       else if (! (DCmpBlock = malloc((unsigned) TopicBlockSize)))
  215.           FAIL("Not enough memory to handle |TOPIC file");
  216.       DecompSize = 0;   /* Set initial size to 0 */
  217.       /* Don't really need first block header, so get it out of the way */
  218.       fread(&BlockHeader, sizeof(BlockHeader), 1, HelpFile);
  219.    }
  220.  
  221.    BytesLeft = NumBytes;
  222.    while (BytesLeft) {
  223.       if (DecompSize == CurrBlockLoc) {
  224.          BlkNum++;
  225.  
  226.          if (Compressed) {
  227.             DecompSize = Decompress(HelpFile, (long)TopicBlockSize-1, 
  228.                 (char *)DCmpBlock);
  229.             /* Align ourselves at next 4k block */
  230.             fseek(HelpFile, TopicStart + (4096L * BlkNum), SEEK_SET);
  231.          }
  232.          else
  233.             DecompSize=fread(DCmpBlock,1,(unsigned) TopicBlockSize, HelpFile);
  234.  
  235.          CurrBlockLoc = 0;
  236.          fread(&BlockHeader, sizeof(BlockHeader), 1, HelpFile);
  237.  
  238.          // Get offset of last topic link. (Don't need block #, hence 3FFFh)
  239.          EndOffset = BlockHeader.LastTopicLink & 0x3FFF;
  240.          TempLink = (TOPICLINK*)(DCmpBlock + EndOffset-sizeof(BlockHeader));
  241.  
  242.          /* Actual end of the data (Don't include header) */
  243.          EndOffset += (TempLink->BlockSize - sizeof(BlockHeader));
  244.  
  245.          // If end shorter than topic block use it; else topic block full
  246.          if (EndOffset > DecompSize) {
  247.              /* Adjust DecompSize if crossing 4k boundary */
  248.              EndOffset = TempLink->BlockSize-((TempLink->NextBlock) & 0x3FFF);
  249.              DecompSize = (BlockHeader.LastTopicLink & 0x3FFF) + EndOffset;
  250.          }
  251.          else DecompSize = EndOffset;
  252.      } /* If */
  253.  
  254.      *(Dest++) = *(DCmpBlock + (CurrBlockLoc++) );
  255.       BytesLeft--;
  256.    } /* While (BytesLeft) */
  257.    return NumBytes;
  258. }
  259.  
  260. // Displays a string from a topic link record. Checks for Phrase
  261. // replacement and non-printable chars
  262. void TopicStringPrint(char *String, long Length) {
  263.    BYTE            Byte1, Byte2;
  264.    int             CurChar, PhraseNum;
  265.    long            counter;
  266.  
  267.    for (counter = 0; counter < Length; counter++) {
  268.       CurChar = * ((char *) (String + counter));
  269.  
  270.       /* Check for Phrase replacement! */
  271.       if ((CurChar > 0) && (CurChar < 10)) {
  272.          Byte1 = (BYTE) CurChar;
  273.          counter++;
  274.          CurChar = * ((char *) (String + counter));
  275.          Byte2 = (BYTE) CurChar;
  276.          PhraseNum = (256 * (Byte1 - 1) + Byte2);
  277.  
  278.          /* If there's a remainder, we have a space after the phrase */
  279.          PrintPhrase(PhrasesPtr, PhraseNum / 2);
  280.          if (PhraseNum % 2) putchar(' ');
  281.       }
  282.       else if (isprint(CurChar)) putchar(CurChar);
  283.       else putchar(' ');    // could do newline for 0x00 0x00
  284.    }
  285. }
  286.  
  287. // Dump |TOPIC file, doing decompression and phrase substitution
  288. void TopicDump(FILE *HelpFile, long FileStart) {
  289.    FILEHEADER      FileHdr;
  290.    TOPICHEADER     *TopicHdr;
  291.    TOPICLINK       TopicLink;
  292.  
  293.    /* Go to the TOPIC file and get the headers */
  294.    fseek(HelpFile, FileStart, SEEK_SET);
  295.    fread(&FileHdr, sizeof(FileHdr), 1, HelpFile);
  296.  
  297.    do {
  298.       TopicRead((BYTE *) &TopicLink, sizeof(TopicLink) - 4, HelpFile);
  299.  
  300.       if (Compressed)
  301.          TopicLink.DataLen2 = TopicLink.BlockSize - TopicLink.DataLen1;
  302.  
  303.       TopicLink.LinkData1=(BYTE *) malloc((unsigned)(TopicLink.DataLen1-21));
  304.       if(!TopicLink.LinkData1)
  305.           MSG("Error allocating TopicLink.LinkData1");
  306.       TopicRead(TopicLink.LinkData1, TopicLink.DataLen1 - 21, HelpFile);
  307.       if (TopicLink.DataLen2 > 0) {
  308.           TopicLink.LinkData2=(BYTE*)malloc((unsigned)(TopicLink.DataLen2+1));
  309.           if(!TopicLink.LinkData2)
  310.              MSG("Error allocating TopicLink.LinkData2");
  311.           TopicRead(TopicLink.LinkData2, TopicLink.DataLen2, HelpFile);
  312.       }
  313.  
  314.       /* Display a Topic Header record */
  315.       if (TopicLink.RecordType == TL_TOPICHDR) {
  316.          TopicHdr = (TOPICHEADER *)TopicLink.LinkData1;
  317.          printf("================ Topic Block Data ====================\n");
  318.          printf("Topic#: %ld - ", TopicHdr->TopicNum);
  319.  
  320.          if (TopicLink.DataLen2 > 0)
  321.             TopicStringPrint(TopicLink.LinkData2, (long) TopicLink.DataLen2);
  322.          else printf("\n");
  323.       }
  324.  
  325.       /* Show a 'text' type record. */
  326.       else if (TopicLink.RecordType == TL_DISPLAY) {
  327.          printf("-- Topic Link Data\n");
  328.          TopicStringPrint(TopicLink.LinkData2, (long) TopicLink.DataLen2);
  329.       }
  330.       printf("\n\n");
  331.       free(TopicLink.LinkData1);
  332.       if (TopicLink.DataLen2 > 0) free(TopicLink.LinkData2);
  333.    } while(TopicLink.NextBlock != -1);
  334. }
  335.  
  336. void DumpFile(FILE *HelpFile) {
  337.     long    FileOffset, PhraseOffset, TopicOffset;
  338.     DWORD   i;
  339.     char    FileName[32];
  340.  
  341.     fread(&HelpHeader, sizeof(HelpHeader), 1, HelpFile);
  342.     if (HelpHeader.MagicNumber != 0x35F3FL)
  343.         MSG("Fatal Error:  Not a valid WinHelp file");
  344.     WHIFSGetFirstLeaf(HelpFile);
  345.     TopicOffset = PhraseOffset = 0;
  346.  
  347.     for (i=0; i<WHIFSHeader.TotalWHIFSEntries; i++) {
  348.        GetFile(HelpFile, i, &FileOffset, FileName);
  349.        if (! strcmp(FileName, "|SYSTEM")) SysLoad(HelpFile, FileOffset);
  350.        else if (! strcmp(FileName, "|Phrases")) PhraseOffset = FileOffset;
  351.        else if (! strcmp(FileName, "|TOPIC")) TopicOffset = FileOffset;
  352.        }
  353.        if (PhraseOffset) PhrasesLoad(HelpFile, PhraseOffset);
  354.        if (TopicOffset) TopicDump(HelpFile, TopicOffset);
  355.        else MSG("No Topic file found!");
  356. }
  357.  
  358. int main(int argc, char *argv[]) {
  359.     char filename[40];
  360.     FILE *HelpFile;
  361.  
  362.     if (argc < 2) { 
  363.        printf("Usage: TOPICDMP helpfile[.hlp]\n\n");
  364.        printf("   helpfile      - Name of help file (.HLP or .MVB)\n\n");
  365.        return EXIT_FAILURE;
  366.        }
  367.  
  368.     if (! strchr(strcpy(filename, strupr(argv[1])), '.'))
  369.        strcat(filename, ".HLP");
  370.  
  371.     if ((HelpFile = fopen(filename, "rb")) == NULL) {
  372.        printf("Can't open %s!", filename);
  373.        return EXIT_FAILURE;
  374.     }
  375.  
  376.     DumpFile(HelpFile);
  377.     fclose(HelpFile);
  378.     return EXIT_SUCCESS;
  379. }
  380.  
  381.